{
    "cells": [
        {
            "cell_type": "markdown",
            "id": "64a64d79",
            "metadata": {},
            "source": [
                "# Sample-Based Krylov Quantum Diagonalization (SKQD)\n",
                "\n",
                "**Sample-Based Krylov Quantum Diagonalization (SKQD)** is a hybrid quantum-classical algorithm that combines the theoretical guarantees of Krylov Quantum Diagonalization (KQD) with the practical efficiency of sample-based methods. Instead of expensive quantum measurements to compute Hamiltonian matrix elements, SKQD samples from quantum states to construct a computational subspace, then diagonalizes the Hamiltonian within that subspace classically.\n",
                "\n",
                "## Why SKQD?\n",
                "\n",
                "Traditional quantum algorithms like VQE face several fundamental challenges:\n",
                "\n",
                "- **Optimization complexity**: VQE requires optimizing many variational parameters in a high-dimensional, non-convex landscape\n",
                "- **Measurement overhead**: Computing expectation values $\\langle\\psi(\\theta)|H|\\psi(\\theta)\\rangle$ requires many measurements for each Pauli term\n",
                "- **Barren plateaus**: Optimization landscapes can become exponentially flat, making gradient-based optimization ineffective\n",
                "- **Parameter initialization**: Poor initial parameters can lead to local minima far from the global optimum\n",
                "\n",
                "SKQD addresses these fundamental limitations:\n",
                "\n",
                "- ✅ **No optimization required**: Uses deterministic quantum time evolution instead of variational circuits\n",
                "- ✅ **Provable convergence**: Theoretical guarantees based on the Rayleigh-Ritz variational principle\n",
                "- ✅ **Measurement efficient**: Only requires computational basis measurements (Z-basis), the most natural measurement on quantum hardware  \n",
                "- ✅ **Noise resilient**: Can filter out problematic measurement outcomes and handle finite sampling\n",
                "- ✅ **Systematic improvement**: Increasing Krylov dimension monotonically improves ground state estimates\n",
                "- ✅ **Hardware friendly**: Time evolution circuits are more amenable to near-term quantum devices than deep variational ansätze\n",
                "\n",
                "\n",
                "\n"
            ]
        },
        {
            "cell_type": "markdown",
            "id": "79bc6748",
            "metadata": {},
            "source": [
                "## Understanding Krylov Subspaces\n",
                "\n",
                "### What is a Krylov Subspace?\n",
                "\n",
                "A **Krylov subspace** $\\mathcal{K}^r$ of dimension $r$ is the space spanned by vectors obtained by repeatedly applying an operator $A$ to a reference vector $|\\psi\\rangle$:\n",
                "\n",
                "$$\\mathcal{K}^r = \\text{span}\\{|\\psi\\rangle, A|\\psi\\rangle, A^2|\\psi\\rangle, \\ldots, A^{r-1}|\\psi\\rangle\\}$$\n",
                "\n",
                "\n",
                "\n",
                "### The SKQD Algorithm\n",
                "\n",
                "The key insight of SKQD is that we can:\n",
                "1. **Generate** Krylov states $U^k|\\psi\\rangle$ using quantum time evolution\n",
                "2. **Sample** from these states to get computational basis measurements\n",
                "3. **Combine** all samples to form a computational subspace\n",
                "4. **Diagonalize** the Hamiltonian within this subspace classically\n",
                "\n",
                "This approach is much more efficient than computing matrix elements via quantum measurements!\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "id": "568f214d",
            "metadata": {},
            "outputs": [],
            "source": [
                "import cudaq\n",
                "import matplotlib.pyplot as plt\n",
                "import cupy as cp\n",
                "import numpy as np\n",
                "from skqd_src.pre_and_postprocessing import *\n",
                "\n",
                "use_gpu = True #this is for postprocessing, the quantum circuit simulation is done on GPU via the nvidia target using CUDA-Q\n",
                "if use_gpu == True:\n",
                "    from cupyx.scipy.sparse import csr_matrix\n",
                "    from cupyx.scipy.sparse.linalg import eigsh\n",
                "else:       \n",
                "    from scipy.sparse import csr_matrix\n",
                "    from scipy.sparse.linalg import eigsh\n",
                "\n",
                "\n",
                "cudaq.set_target('nvidia') \n",
                "cudaq.set_random_seed(42)\n",
                "np.random.seed(43)\n",
                "cp.random.seed(44)\n"
            ]
        },
        {
            "cell_type": "markdown",
            "id": "28cb9f2d",
            "metadata": {},
            "source": [
                "## Problem Setup: 22-Qubit Heisenberg Model\n",
                "\n",
                "We'll demonstrate SKQD on a 1D Heisenberg spin chain with 22 qubits:\n",
                "\n",
                "$$H = \\sum_{i} \\left(J_x \\sigma_i^x \\sigma_{i+1}^x + J_y \\sigma_i^y \\sigma_{i+1}^y + J_z \\sigma_i^z \\sigma_{i+1}^z\\right) + \\sum_i \\left(h_x \\sigma_i^x + h_y \\sigma_i^y + h_z \\sigma_i^z\\right)$$\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 2,
            "id": "85c715f1",
            "metadata": {},
            "outputs": [],
            "source": [
                "num_spins = 22 \n",
                "\n",
                "if num_spins >= 63:\n",
                "    raise ValueError(f\"Vectorized implementation of postprocessing supports max 62 qubits due to int64 packing. Requested: {num_spins}\")\n",
                "\n",
                "shots = 100_000  \n",
                "\n",
                "total_time_evolution = np.pi  \n",
                "num_trotter_steps = 8  \n",
                "dt = total_time_evolution / num_trotter_steps  \n",
                "\n",
                "max_k = 12  # largest k for U^k\n",
                "\n",
                "eigenvalue_solver_options = {\"k\": 2, \"which\": \"SA\"}  # Find 2 smallest eigenvalues\n",
                "\n",
                "\n",
                "\n",
                "Jx, Jy, Jz = 1.0, 1.0, 1.0 \n",
                "h_x, h_y, h_z = np.ones(num_spins), np.ones(num_spins), np.ones(num_spins)\n",
                "H = create_heisenberg_hamiltonian(num_spins, Jx, Jy, Jz, h_x, h_y, h_z)\n",
                "exact_ground_state_energy = -38.272304 # Computed via exact diagonalization\n",
                "hamiltonian_coefficients, pauli_words = extract_coeffs_and_paulis(H)\n",
                "hamiltonian_coefficients_numpy = np.array(hamiltonian_coefficients)"
            ]
        },
        {
            "cell_type": "markdown",
            "id": "9cd4c837",
            "metadata": {},
            "source": [
                "## Krylov State Generation via Repeated Evolution\n",
                "\n",
                "For SKQD, we generate the Krylov sequence:\n",
                "$$|\\psi_0\\rangle,  U|\\psi_0\\rangle,  U^2|\\psi_0\\rangle, \\ldots,  U^{k-1}|\\psi_0\\rangle$$\n",
                "\n",
                "where $U = e^{-iHT}$ is approximated via Trotter decomposition.\n",
                "\n",
                "**Implementation Strategy**:\n",
                "1. Start with reference state $|\\psi_0\\rangle$\n",
                "2. Apply Trotter-decomposed time evolution $k$ times for $U^k|\\psi_0\\rangle$\n",
                "3. Measure each Krylov state in computational basis\n",
                "4. Accumulate measurement statistics across all Krylov powers\n",
                "\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 3,
            "id": "44e3422c",
            "metadata": {
                "execution": {
                    "iopub.execute_input": "2025-09-08T14:32:51.773472Z",
                    "iopub.status.busy": "2025-09-08T14:32:51.773267Z",
                    "iopub.status.idle": "2025-09-08T14:32:51.783809Z",
                    "shell.execute_reply": "2025-09-08T14:32:51.783445Z"
                }
            },
            "outputs": [],
            "source": [
                "@cudaq.kernel\n",
                "def quantum_krylov_evolution_circuit(\n",
                "        num_qubits: int, \n",
                "        krylov_power: int, \n",
                "        trotter_steps: int,\n",
                "        dt: float,\n",
                "        H_pauli_words: list[cudaq.pauli_word],\n",
                "        H_coeffs: list[float]):\n",
                "    \n",
                "    \"\"\"\n",
                "    Generate Krylov states via repeated time evolution.\n",
                "    \n",
                "    Args:\n",
                "        num_qubits: Number of qubits in the system\n",
                "        krylov_power: Power k for computing U^k|ψ⟩\n",
                "        trotter_steps: Number of Trotter steps for each U application\n",
                "        dt: Time step for Trotter decomposition\n",
                "        H_pauli_words: Pauli decomposition of Hamiltonian\n",
                "        H_coeffs: Coefficients for each Pauli term\n",
                "    \n",
                "    Returns:\n",
                "        Measurement results in computational basis\n",
                "    \"\"\"\n",
                "    \n",
                "    qubits = cudaq.qvector(num_qubits)\n",
                "\n",
                "    #Prepare Néel state as reference |010101...⟩\n",
                "    for qubit_index in range(num_qubits):\n",
                "        if qubit_index % 2 == 0:\n",
                "            x(qubits[qubit_index])\n",
                "\n",
                "\n",
                "    for _ in range(krylov_power):                                            #applies U^k where U = exp(-iHT)\n",
                "        \n",
                "        for _ in range(trotter_steps):                                       #applies exp(-iHT)\n",
                "            \n",
                "            for i in range(len(H_coeffs)):                                   #applies exp(-iHdt)\n",
                "                exp_pauli( -1 * H_coeffs[i] * dt, qubits, H_pauli_words[i])  #applies exp(-ihdt)\n",
                "\n",
                "\n",
                "    mz(qubits)"
            ]
        },
        {
            "cell_type": "markdown",
            "id": "981f54b4",
            "metadata": {},
            "source": [
                "## Quantum Measurements and Sampling\n",
                "\n",
                "\n",
                "### The Sampling Process\n",
                "\n",
                "For each krylov power $ = 0, 1, 2, \\ldots, k-1$:\n",
                "1. **Prepare** the state $U^k|\\psi\\rangle$ using our quantum circuit\n",
                "2. **Measure** in the computational basis many times\n",
                "3. **Collect** the resulting bitstring counts\n",
                "\n",
                "The key insight: these measurement outcomes give us a statistical representation of each Krylov state, which we can then use to construct our computational subspace classically.\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 4,
            "id": "ccca2170",
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Generating Krylov state U^0...\n",
                        "Generating Krylov state U^1...\n",
                        "Generating Krylov state U^2...\n",
                        "Generating Krylov state U^3...\n",
                        "Generating Krylov state U^4...\n",
                        "Generating Krylov state U^5...\n",
                        "Generating Krylov state U^6...\n",
                        "Generating Krylov state U^7...\n",
                        "Generating Krylov state U^8...\n",
                        "Generating Krylov state U^9...\n",
                        "Generating Krylov state U^10...\n",
                        "Generating Krylov state U^11...\n"
                    ]
                }
            ],
            "source": [
                "all_measurement_results = []\n",
                "\n",
                "for krylov_power in range(max_k):\n",
                "    print(f\"Generating Krylov state U^{krylov_power}...\")\n",
                "    \n",
                "    sampling_result = cudaq.sample(\n",
                "        quantum_krylov_evolution_circuit,\n",
                "        num_spins,  \n",
                "        krylov_power, \n",
                "        num_trotter_steps,  \n",
                "        dt,  \n",
                "        pauli_words,  \n",
                "        hamiltonian_coefficients, \n",
                "        shots_count=shots) \n",
                "        \n",
                "    all_measurement_results.append(dict(sampling_result.items()))\n",
                "    \n",
                "\n",
                "cumulative_results = calculate_cumulative_results(all_measurement_results)\n"
            ]
        },
        {
            "cell_type": "markdown",
            "id": "36a00631",
            "metadata": {},
            "source": [
                "## Classical Post-Processing and Diagonalization\n",
                "\n",
                "Now comes the classical part of SKQD: we use our quantum measurement data to construct and diagonalize the Hamiltonian within each Krylov subspace.\n",
                "\n",
                "1. **Extract basis states** from measurement counts\n",
                "2. **Project Hamiltonian** onto the computational subspace spanned by these states  \n",
                "3. **Diagonalize** the projected Hamiltonian classically\n",
                "4. **Extract ground state energy** estimate\n",
                "\n",
                "\n",
                "\n",
                "### The SKQD Algorithm: Matrix Construction Details\n",
                "\n",
                "The core of SKQD is constructing the effective Hamiltonian matrix within the computational subspace:\n",
                "\n",
                "1. **Computational Subspace Formation**: From quantum measurements, we obtain a set of computational basis states $\\{|s_1\\rangle, |s_2\\rangle, \\ldots, |s_d\\rangle\\}$ that spans our approximation to the Krylov subspace.\n",
                "\n",
                "2. **Matrix Element Computation**: For each Pauli term $P_k$ in the Hamiltonian with coefficient $h_k$:\n",
                "   $$H = \\sum_k h_k P_k$$\n",
                "   \n",
                "   We compute matrix elements: $\\langle s_i | P_k | s_j \\rangle$ by applying the Pauli string $P_k$ to each basis state $|s_j\\rangle$.\n",
                "\n",
                "3. **Effective Hamiltonian**: The projected Hamiltonian becomes:\n",
                "   $$H_{\\text{eff}}[i,j] = \\sum_k h_k \\langle s_i | P_k | s_j \\rangle$$\n",
                "\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 5,
            "id": "6bed2897",
            "metadata": {},
            "outputs": [],
            "source": [
                "energies = []\n",
                "\n",
                "for k in range(1, max_k):\n",
                "\n",
                "    cumulative_subspace_results = cumulative_results[k]\n",
                "    basis_states = get_basis_states_as_array(cumulative_subspace_results, num_spins)\n",
                "    subspace_dimension = len(cumulative_subspace_results)\n",
                "    assert len(cumulative_subspace_results) == basis_states.shape[0]\n",
                "\n",
                "    # matrix_rows, matrix_cols, matrix_elements = projected_hamiltonian(basis_states, pauli_words, hamiltonian_coefficients_numpy, verbose) #slower non-vectorized implementation\n",
                "\n",
                "    #if use_gpu is True, the projected hamiltonian & eigenvalue solver are computed on the GPU\n",
                "    matrix_rows, matrix_cols, matrix_elements = vectorized_projected_hamiltonian(basis_states, pauli_words, hamiltonian_coefficients_numpy, use_gpu)\n",
                "    projected_hamiltonian = csr_matrix((matrix_elements, (matrix_rows, matrix_cols)), shape=(subspace_dimension, subspace_dimension))\n",
                "    eigenvalue = eigsh(projected_hamiltonian, return_eigenvectors=False, **eigenvalue_solver_options)\n",
                "  \n",
                "    energies.append(np.min(eigenvalue).item())\n"
            ]
        },
        {
            "cell_type": "markdown",
            "id": "f36b27e7",
            "metadata": {},
            "source": [
                "## Results Analysis and Convergence\n",
                "\n",
                "Let's visualize our results and analyze how SKQD converges to the true ground state energy. This is the moment of truth - does our quantum-classical hybrid algorithm work?\n",
                "\n",
                "### What to Expect:\n",
                "\n",
                "- **Monotonic improvement**: Each additional Krylov dimension should give a better (lower) energy estimate\n",
                "- **Convergence**: The estimates should approach the exact ground state energy  \n",
                "- **Diminishing returns**: Later Krylov dimensions provide smaller improvements\n",
                "\n",
                "The exact ground state energy for our selected Hamiltonian was computed earlier via classical exact diagonalization and will be used as the reference for comparison with SKQD results.\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 6,
            "id": "ab727651",
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 500x400 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "# Create visualization of SKQD convergence\n",
                "\n",
                "plt.figure(figsize=(5, 4))\n",
                "all_dims = range(1, max_k)\n",
                "\n",
                "plt.plot(all_dims, energies, 'o-', linewidth=2, markersize=8, label='SKQD')\n",
                "plt.plot(all_dims, [exact_ground_state_energy] * (max_k-1), 'g', linewidth=2, label='Exact ground state')\n",
                "\n",
                "plt.xticks(all_dims)\n",
                "plt.xlabel(\"Krylov Subspace Dimension\", fontsize=12)\n",
                "plt.ylabel(\"Ground State Energy\", fontsize=12)\n",
                "plt.title(\"Ground State Energy vs Krylov Dimension\", fontsize=14, pad=20)\n",
                "plt.legend(fontsize=11)\n",
                "plt.grid(True, alpha=0.3)\n",
                "\n",
                "final_error = abs(energies[-1] - exact_ground_state_energy)\n",
                "plt.text(0.02, 0.98, f'Final error: {final_error:.6f}\\nExact energy: {exact_ground_state_energy:.6f}',\n",
                "         transform=plt.gca().transAxes, verticalalignment='top',\n",
                "         bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.8))\n",
                "plt.tight_layout()\n",
                "\n",
                "plt.show()"
            ]
        },
        {
            "cell_type": "markdown",
            "id": "042aa6aa",
            "metadata": {},
            "source": [
                "## GPU Acceleration for Postprocessing \n",
                "\n",
                "The critical postprocessing operations are:\n",
                "\n",
                "1. Hamiltonian projection onto computational subspace\n",
                "\n",
                "`matrix_rows, matrix_cols, matrix_elements = vectorized_projected_hamiltonian(basis_states, pauli_words, hamiltonian_coefficients_numpy, use_gpu)`\n",
                "\n",
                "2. Sparse matrix construction\n",
                "\n",
                "`projected_hamiltonian = csr_matrix((matrix_elements, (matrix_rows, matrix_cols)), shape=(subspace_dimension, subspace_dimension))`\n",
                "\n",
                "3. Eigenvalue computation\n",
                "\n",
                "`eigenvalue = eigsh(projected_hamiltonian, return_eigenvectors=False, **eigenvalue_solver_options)`\n",
                "\n",
                "This substantial acceleration comes from:\n",
                "- **Parallel Pauli string evaluation** across thousands of basis states simultaneously\n",
                "- **Vectorized matrix element computation** leveraging CUDA cores\n",
                "- **GPU-optimized sparse linear algebra** via cuSPARSE library for eigenvalue solving\n",
                "\n",
                "The speedup becomes increasingly critical as the Krylov dimension grows, since the computational subspace dimension (and thus the matrix size) scales exponentially with k. For higher k values, GPU acceleration transforms previously intractable postprocessing into feasible computation times.\n",
                "\n",
                "**Note**: Set `use_gpu = True` at the beginning of the notebook to enable GPU acceleration for postprocessing. The quantum circuit simulation uses the NVIDIA target in CUDA-Q regardless of this flag."
            ]
        },
        {
            "cell_type": "markdown",
            "id": "230e700d",
            "metadata": {},
            "source": [
                "<img src=\"images/speedup.png\" width=\"600\">"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 7,
            "id": "2d422417",
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Using: CUDA-Q Version  (https://github.com/NVIDIA/cuda-quantum 37053302ceb3d83684186b2a99aac500df7b847e)\n"
                    ]
                }
            ],
            "source": [
                "print(\"Using:\", cudaq.__version__)"
            ]
        }
    ],
    "metadata": {
        "kernelspec": {
            "display_name": "Python 3",
            "language": "python",
            "name": "python3"
        },
        "language_info": {
            "codemirror_mode": {
                "name": "ipython",
                "version": 3
            },
            "file_extension": ".py",
            "mimetype": "text/x-python",
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
            "version": "3.12.3"
        }
    },
    "nbformat": 4,
    "nbformat_minor": 5
}
